package 题目集.并查集;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
//https://pintia.cn/problem-sets/1734589674052866048/exam/problems/1734589708576198660?type=7&page=0
public class 部落 {
    /**
     * 思路：
     *      构建并查集，
     *
     */
    public static void main(String[] args) throws IOException {
        BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
        int n=Integer.parseInt(in.readLine());
        UnionFindSet<Integer> unionSet=new UnionFindSet<>();
        String[] read=null;
        while (n-- > 0) {
            read=in.readLine().split(" ");
            int pre = Integer.parseInt(read[1]);
            unionSet.init(pre);
            for (int i = 2; i < read.length; i++) {
                int curr = Integer.parseInt(read[i]);
                unionSet.union(pre,curr);
                pre=curr;
            }
        }
        n=Integer.parseInt(in.readLine());
        System.out.println(unionSet.getAllCount()+" "+ unionSet.getSetCount());
        while (n-->0){
            read=in.readLine().split(" ");
            boolean isSame = unionSet.isSameSet(Integer.parseInt(read[0]), Integer.parseInt(read[1]));
            if (isSame){
                System.out.println("Y");
            }else {
                System.out.println("N");
            }
        }
    }

    /**
     * 并查集2.2版本，可以获取每个父节点的集合大小，以及获取集合个数.
     * 优化存储方式
     * 注意：使用此类需要重写T的hashCode与equals
     */
    static class UnionFindSet<T> {
        /**
         * 存放父集合与子集和的映射
         */
        Map<T,T> map =new HashMap<>();
        /**
         * 存放每个集合的个数
         */
        Map<T,Integer> sizeMap=new HashMap<>();
        /**
         * 存放集合的根节点
         */
//    Set<T> set=new HashSet<>();

        public UnionFindSet() {

        }

        public UnionFindSet(Collection<T> collection) {
            for (T t : collection) {
                map.put(t,t);
            }
        }

        /**
         * 我需要在这个操作中完成什么？
         * 1.将小集合的父节点指向大集合。
         * 2.更新大集合的size。
         * 3.从set中移除小集合。
         */
        public void union(T a,T b){
            if (!map.containsKey(a)){
                init(a);
            }
            if (!map.containsKey(b)){
                init(b);
            }
            if (a.equals(b)){
                return;
            }
            T parentA = find(a);
            T parentB = find(b);
            if (parentA.equals(parentB)){
                return;
            }
            int sizeA=sizeMap.get(parentA);
            int sizeB =sizeMap.get(parentB);
            T small=null;
            T more=null;
            if(sizeA>sizeB){
                more=parentA;
                small=parentB;
            }else{
                more=parentB;
                small=parentA;
            }
            sizeMap.put(more,sizeA+sizeB);
            map.put(small,more);
            sizeMap.remove(small);
        }
        public void init(T o){
            if (map.containsKey(o)){    //已经初始化过就退出
                return;
            }
            map.put(o,o);
            sizeMap.put(o,1);
//        set.add(o);
        }

        /**
         * 查找o的真正父节点，在这个过程中会使o及其所有父节点指向真正的父节点。
         */
        public T find(T o){
            T parent = map.get(o);
            if (parent==null||parent.equals(o)){
                return o;
            }
            parent=find(parent);
            map.put(o,parent);
            return parent;
        }

        /**
         * 返回target所在集合的大小
         */
        public int getSetSize(T target){
            Integer size = sizeMap.get(find(target));
            return size==null?0:size;
        }
        public int getSetCount(){
            return sizeMap.size();
        }
        public int getAllCount(){
            return map.size();
        }

        public boolean isSameSet(T o1,T o2){
            return find(o1).equals(find(o2));
        }

        public Map<T,Integer> getSizeMap(){
            return sizeMap;
        }
    }
}
